﻿using DG.Tweening; // 使用DOTween动画系统
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;

/// <summary>
/// 卡牌系统管理器，负责卡牌的抽牌、弃牌、手牌管理等核心逻辑
/// 采用单例模式保证全局唯一访问
/// </summary>
public class CardSystem : Singleton<CardSystem>
{
    [Header("视图引用")]
    [SerializeField] private HandView handView;          // 手牌视图控制器
    [SerializeField] private Transform drawPilePoint;   // 抽牌堆位置参考点
    [SerializeField] private Transform discardPilePoint; // 弃牌堆位置参考点

    [Header("卡牌集合")]
    public List<Card> drawPile = new ();    // 抽牌堆（未抽取的卡牌）
    public List<Card> discardPile = new(); // 弃牌堆（已使用卡牌）
    public List<Card> hand = new ();        // 当前手牌

    #region 生命周期管理
    private void OnEnable()
    {
        // 注册游戏动作处理器
        ActionSystem.AttachPerformer<DrawCardGA>(DrawCardsPerformer);
        ActionSystem.AttachPerformer<DiscardAllCardsGA>(DiscardAllCardsPerformer);
        ActionSystem.AttachPerformer<PlayCardGA>(PlayCardPerformer);
    }



    private void OnDisable()
    {
        // 注销处理器和事件
        ActionSystem.DetachPerformer<DrawCardGA>();
        ActionSystem.DetachPerformer<DiscardAllCardsGA>();
        ActionSystem.DetachPerformer<PlayCardGA>();

    }
    #endregion

    /// <summary>
    /// 初始化卡牌系统
    /// </summary>
    /// <param name="cardDatas">卡牌数据集合</param>
    public void SetUp(List<CardData> cardDatas)
    {
        foreach (CardData cardData in cardDatas)
        {
            // 根据卡牌数据创建卡牌实例并加入抽牌堆
            Card card = new (cardData);
            drawPile.Add(card);
        }
    }

    #region 核心卡牌操作
    /// <summary>
    /// 执行抽牌动作（协程）
    /// </summary>
    /// <param name="drawCardGA">抽牌游戏动作，包含抽牌数量</param>
    private IEnumerator DrawCardsPerformer(DrawCardGA drawCardGA)
    {
        // 计算实际可抽取数量（考虑牌堆剩余卡牌）
        int actualDrawCount = Mathf.Min(drawCardGA.Amount, drawPile.Count);
        int notDrawCount = drawCardGA.Amount - actualDrawCount;

        // 第一阶段抽牌
        for (int i = 0; i < actualDrawCount; i++)
        {
            yield return DrawCard(); // 单张抽牌协程
        }

        // 如果需求数量不足，重新洗牌后继续抽牌
        if (notDrawCount > 0)
        {
            RefillDeck(); // 将弃牌堆洗回抽牌堆
            for (int i = 0; i < notDrawCount; i++)
            {
                yield return DrawCard();
            }
        }
    }

    /// <summary>
    /// 单张抽牌逻辑（协程）
    /// </summary>
    private IEnumerator DrawCard()
    {
        Card card = drawPile.Draw(); // 从抽牌堆顶部取牌
        hand.Add(card); // 加入手牌列表
       // Debug.Log($"抽牌成功，手牌id：{card.ID}");

        // 创建卡牌视图并添加到手牌视图
        CardView cardView = CardViewCreator.instance.CreateCardView(
            card,
            drawPilePoint.position,
            drawPilePoint.rotation
        );

        yield return handView.AddCard(cardView); // 等待添加动画完成
    }

    /// <summary>
    /// 执行弃牌动作（协程）
    /// </summary>
    /// <param name="discardCardGA">弃牌游戏动作</param>
    private IEnumerator DiscardAllCardsPerformer(DiscardAllCardsGA discardCardGA)
    {
        // 遍历所有手牌执行弃牌
        foreach (Card card in hand)
        {
            CardView cardView = handView.RemoveCard(card); // 从手牌视图移除
            yield return DiscardCard(cardView); // 执行弃牌动画
        }
        hand.Clear(); // 清空手牌列表
    }

    /// <summary>
    /// 单张卡牌弃牌动画（协程）
    /// </summary>
    /// <param name="cardView">要弃掉的卡牌视图</param>
    private IEnumerator DiscardCard(CardView cardView)
    {
        // 1. 参数检查
        if (cardView == null || cardView.Card == null)
        {
            Debug.Log("尝试弃置无效的卡牌视图");
        }

        // 2. 添加到弃牌堆
        discardPile.Add(cardView.Card);
        Debug.Log($"卡牌 ID:{cardView.Card.ID} 已加入弃牌堆");

        // 3. 执行动画
    
        cardView.transform.DOScale(Vector3.zero, 0.5f);
        Tween tween = cardView.transform.DOMove(discardPilePoint.position, 0.5f);
        yield return tween.WaitForCompletion();


        // 4. 销毁卡牌视图
        if (cardView != null && cardView.gameObject != null)
        {
            Destroy(cardView.gameObject);
        }
    }

    /// <summary>
    /// 将弃牌堆洗回抽牌堆
    /// </summary>
    private void RefillDeck()
    {
        drawPile.AddRange(discardPile); // 合并弃牌堆到抽牌堆
        discardPile.Clear(); // 清空弃牌堆
    }

    private IEnumerator PlayCardPerformer(PlayCardGA playerCardGA)
    {
        // 1. 增强参数检查
        if (playerCardGA == null)
        {
            Debug.Log("playerCardGA 无效的出牌动作");
        }

        if ( playerCardGA.Card == null)
        {
            Debug.Log("playerCardGA.Card 参数为空");
        }

        // 2. 获取卡牌ID用于调试
        Guid cardId = playerCardGA.Card.ID;
        Debug.Log($"尝试出牌 ID:{cardId}");

        // 3. 使用ID查找卡牌（更安全的方式）
        Card cardToRemove = hand.Find(c => c != null && c.ID == cardId);
        if (cardToRemove == null)
        {
            Debug.Log($"卡牌 ID:{cardId} 不在手牌中。当前手牌数:{hand.Count}");
            LogCurrentHand(); // 打印当前手牌信息

        }

        // 4. 从数据层移除
        if (!hand.Remove(cardToRemove))
        {
            Debug.Log($"从手牌移除卡牌 ID:{cardId} 失败");

        }

        // 5. 从视图层移除（使用更安全的移除方式）
        CardView cardView = handView.RemoveCard(cardToRemove);
        if (cardView == null)
        {
            Debug.Log($"找不到卡牌 ID:{cardId} 的视图");
        }

        // 6. 执行弃牌动画
        yield return DiscardCard(cardView);

        // 7. 处理卡牌效果
        try
        {
            // 消耗法力值
            if (playerCardGA.Card.Mana > 0)
            {
                SpendManaGA spendManaGA = new(playerCardGA.Card.Mana);
                ActionSystem.instance.AddReaction(spendManaGA);
            }

            // 执行手动目标效果
            if (playerCardGA.Card.ManualTargetEffect != null)
            {
                PerformEffectGA performEffectGA = new(
                    playerCardGA.Card.ManualTargetEffect,
                    new() { playerCardGA.ManualTarget }
                );
                ActionSystem.instance.AddReaction(performEffectGA);
            }

            // 执行其他效果
            foreach (var effectWrapper in playerCardGA.Card.OhterEffect)
            {
                List<CombatantView> targets = effectWrapper.TargetMode.GetTargets();
                PerformEffectGA performEffectGA = new(effectWrapper.Effect, targets);
                ActionSystem.instance.AddReaction(performEffectGA);
            }
        }
        catch (Exception e)
        {
            Debug.Log($"执行卡牌效果时出错：{e.Message}");
        }
    }

    // 添加调试方法
    private void LogCurrentHand()
    {
        Debug.Log("=== 当前手牌 ===");
        foreach (var card in hand)
        {
            Debug.Log($"ID:{card?.ID}, 名称");
        }
        Debug.Log("===============");
    }


    #endregion

    #region Test
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log(" 抽牌堆"+drawPile.Count);
            Debug.Log(" 弃牌堆"+discardPile.Count);
            Debug.Log(" 手牌牌堆"+hand.Count);

            LogCurrentHand();

        }
    }
    #endregion



}